/**
 * @file UE.h
 * @brief Fichier d'entête du module UE.
 *
 * @author Mohammad NOROUZZADEH, Lotfi, Saleh
 */

#ifndef _UE_H
#define _UE_H


/* ********************************************************************* */
/*                                                                       */
/*                       Librairies de UE                                */
/*                                                                       */
/* ********************************************************************* */

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include <string.h>

#include "UtilStr.h"
#include "Enseignant.h"
#include "Chemin.h"
/* ********************************************************************* */
/*                                                                       */
/*                        Définitions de types                           */
/*                                                                       */
/* ********************************************************************* */

/**
 * @struct UE
 * @brief Structure utilisée pour la gestion d'une UE.
 *
 * Cette structure est utilisée pour gérer .Les champs de cette structures
   doivent être modifiés ou lus par les accesseurs et mutateurs.
 */
struct sUE
    {
    int codeUE;
    char * intitule;
    int sequence;
    };

/**
 * @typedef UE
 * @brief Redéfinit la structure sUE
 */
typedef struct sUE UE ;

/**
 * @struct sTabUe
 * @brief Structure utilisée pour la gestion d'une UE.
 *
 * Cette structure est utilisée pour gérer .Les champs de cette structures
   doivent être modifiés ou lus par les accesseurs et mutateurs.
 */
struct  sTabUe
{
    UE**tabUe;
    int nbUe;
};

/**
 * @typedef TabUe
 * @brief Redéfinit la structure sTabUe
 */
typedef struct  sTabUe  TabUe;

/**
 * @fn void initUE(UE * ue,const int CodeUE,const char * Intitule,const int Sequence);
 * @brief Initialise un UE.
   initUE initialise CodeUE, Intitule et Sequence (après vérification) de la structure UE

 * @param[in, out] ue Pointeur vers l'ue à initialiser.
 * @param[in] CodeUE Code de l'UE.
 * @param[in] Intitule Intitule de l'UE.
 * @param[in] Sequence Sequence de l'UE.
 * @return 0 si tout est OK
 */
void initUE(UE *ue,const int CodeUE,const char * Intitule,const int Sequence);

/**
 * @fn void libUE(UE * ue);
 * @brief Libere un UE en mémoire.

 * @param[in, out] ue Pointeur vers l'ue.
 * @return 0 si tout est OK
 */
void libUE(UE *ue);

/**
 * @fn UE * creUE(const int CodeUE,const char * Intitule,const int Sequence);
 * @brief Crée un UE en mémoire.

 * @param[in] CodeUE Code de l'UE.
 * @param[in] Intitule Hauteur de l'image.
 * @param[in] Sequence Sequence de l'UE.
 * @return un pointeur vers un UE
 */
UE * creUE(const int CodeUE,const char * Intitule,const int Sequence);


/**
 * @fn detruireUE(UE ** ue);
 * @brief Détruit un UE en mémoire.

 * @param[in, out] ue Pointeur vers l'ue.
 * @return 0 si tout est OK
 */
void detUE(UE ** ue);

/* ******************************************************************** */
/*																		*/
/*           Accesseurs et Mutateurs de la structure UE                 */
/*																		*/
/* ******************************************************************** */

/**
 * @fn int getCodeUE(const UE * ue);
 * @brief returner CodeUE.

 * @param[in] ue pointeur vers l'ue.
 * @return CodeUE
 */
int getCodeUE(const UE * ue);

/**
 * @fn void setCodeUE(UE * ue, int CodeUE);
 * @brief modifie le champ CodeUE de l'ue.

 * @param[in, out] ue Pointeur vers l'ue.
 * @param[in] CodeUE Code de l'UE.
 * @return 0 si tout est OK
 */
void setCodeUE(UE * ue, int CodeUE);

/**
 * @fn char * getIntitule(const UE * ue);
 * @brief returner Intitule.

 * @param[in] ue pointeur vers l'ue.
 * @return Intitule.
 */
char * getIntitule(const UE * ue);

/**
 * @fn void setIntitule(UE * ue,char * Intitule);
 * @brief modifie le champ Intitule de l'ue.

 * @param[in, out] ue Pointeur vers l'ue.
 * @param[in] Intitule Intitule de l'UE.
 * @return 0 si tout est OK.
 */
void setIntitule(UE * ue,char * Intitule);

/**
 * @fn int getSequence(UE * ue);
 * @brief returner Sequence.

 * @param[in] ue pointeur vers l'ue.
 * @return Sequence.
 */
int getSequence(UE * ue);

/**
 * @fn void setSequence(UE * ue, int Sequence);
 * @brief modifie le champ Sequence de l'ue.

 * @param[in, out] ue Pointeur vers l'ue.
 * @param[in] Sequence Sequence de l'UE.
 * @return 0 si tout est OK.
 */
void setSequence(UE * ue, int Sequence);

/**
 * @fn void affUE(UE * ue);
 * @brief Afficher l'ue.

 * @param[in] ue pointeur vers l'ue.
 * @return 0 si tout est OK
 */
void affUE(const UE * ue);


/* ********************************************************************* */
/*                                                                       */
/*             Fonctions relatives aux gestiond'UE                       */
/*                                                                       */
/* ********************************************************************* */

/**
 * @fn void savUE(const UE *ue);
 * @brief saover UE dans un fichier binaire.
 *
 * @param[in] UE .

 * @return 0 si tout est OK.
 */
void savUE(const UE *ue);

/**
 * @fn void savUEParElem(const int CodeUE,const char * Intitule,const int Sequence);
 * @brief saover UE dans un fichier binaire.
 *
 * @param[in] CodeUE .
 * @param[in] Intitule .
 * @param[in] Sequence .

 * @return 0 si tout est OK.
 */
void savUEParElem(const int CodeUE,const char * Intitule,const int Sequence);

/**
 * @fn int rchUE(const UE *pEU);
 * @brief recherche UE dans un fichier binaire.
 *
 * @param[in] UE .

 * @return 0 s'il n'existe pas.
 * @return 1 s'il existe.
 */
int rchUE(const UE *pEU);

/**
 * @fn int rchUEParCode(const int codeUE);
 * @brief recherche UE dans un fichier binaire.
 *
 * @param[in] CodeUE .

 * @return 0 s'il n'existe pas.
 * @return 1 s'il existe.
 */
int rchUEParCode(const int codeUE);

/**
 * @fn UE *recUE(const UE *pEU);
 * @brief recupérer UE dans un fichier binaire.
 *
 * @param[in] UE .

 * @return UE s'il n'existe pas.
 * @return NULL s'il existe.
*/
UE *recUE(const UE *pEU);

/**
 * @fn UE *recUEParCode(const int codeUE);
 * @brief recupérer UE dans un fichier binaire.
 *
 * @param[in] CodeUE .

 * @return UE s'il n'existe pas.
 * @return NULL s'il existe.
*/
UE *recUEParCode(int codeUE);

/**
 * @fn int supUE(const UE *pEU);
 * @brief supprimer UE dans un fichier binaire.
 *
 * @param[in] pUE .

 * @return -1 s'il n'existe pas.
 * @return 0 s'il supprime.
 */
int supUE(const UE *pEU);

/**
 * @fn int supUEParCode(const int codeUE);
 * @brief supprimer UE dans un fichier binaire.
 *
 * @param[in] CodeUE .

 * @return -1 s'il n'existe pas.
 * @return 0 s'il supprime.
 */
int supUEParCode(const int codeUE);

/**
 * @fn int mdfUE(const UE *pEU, const UE *nUE);
 * @brief modifier UE dans un fichier binaire.
 *
 * @param[in] UE .
 * @param[in] newUE .

 * @return -1 s'il n'existe pas.
 * @return 1 s'il modifie.
 * @return 0 si non.
 */
int mdfUE(const UE *pEU, const UE *nUE);

/**
 * @fn mdfUEParCode(const int codeUE, const UE *nUE);
 * @brief modifier UE dans un fichier binaire.
 *
 * @param[in] CodeUE .
 * @param[in] UE .

 * @return -1 s'il n'existe pas.
 * @return 1 s'il modifie.
 * @return 0 si non.
 */
int mdfUEParCode(const int codeUE, const UE *nUE);


void setResponsableToUe(Ens*ens,UE*ue);
void setResponsableToUeParCode(int numEns,int codeUe);

/**
 * @fn Ens * recResponsableUeParCode(int codeUe);
 * @brief recupérer responsable d'un UE dans un fichier binaire.
 *
 * @param[in] CodeUE .

 * @return UE s'il n'existe pas.
 * @return NULL s'il existe.
*/
Ens * recResponsableUeParCode(int codeUe);

/**
 * @fn Ens * recResponsableUe(UE*ue);
 * @brief recupérer responsable d'un UE dans un fichier binaire.
 *
 * @param[in] UE .

 * @return UE s'il n'existe pas.
 * @return NULL s'il existe.
*/
Ens * recResponsableUe(UE*ue);

/**
 * @fn TabUe * recUeParEnseignantResp(Ens*ens);
 * @brief recupérer tab UeParEnseignantResp.
 *
 * @param[in]  ens.

 * @return UE s'il n'existe pas.
 * @return NULL s'il existe.
*/
TabUe * recUeParEnseignantResp(Ens*ens);

/**
 * @fn TabUe * recUeParNumEnseignantResp(int numEns);
 * @brief recupérer tabUeParEnseignantResp.
 *
 * @param[in] numens .

 * @return UE s'il n'existe pas.
 * @return NULL s'il existe.
*/
TabUe * recUeParNumEnseignantResp(int numEns);

/**
 * @fn TabUe * recToutUe();
 * @brief recupérer ToutUe.

 * @return UE s'il n'existe pas.
 * @return NULL s'il existe.
*/
TabUe * recToutUe();

/**
 * @fn int supRespUE(UE*ue);
 * @brief supprimer RespUE dans un fichier binaire.
 *
 * @param[in] UE .

 * @return -1 s'il n'existe pas.
 * @return 1 s'il modifie.
 * @return 0 si non.
 */
int supRespUE(UE*ue);

/**
 * @fn int supRespUEParCode(int codeUe);
 * @brief supprimer RespUE dans un fichier binaire.
 *
 * @param[in] codeUE .

 * @return -1 s'il n'existe pas.
 * @return 1 s'il modifie.
 * @return 0 si non.
 */
int supRespUEParCode(int codeUe);


/**
 * @fn affUE_DB();
 * @brief Afficher base de donnee de UE .

 * @return 0 si tout est OK.
 */
void affUE_DB();

/**
 * @fn void regUE() ;
 * @brief Test le module UE
 */
void regUE();

#endif
